#include "BlockQueue.hpp"
#include "Task.hpp"
#include <unistd.h>
using namespace wxd;


//测试传整型
// void* pRoutine(void* args)
// {
//     BlockQueue<int>* bq = static_cast<BlockQueue<int>*>(args);

//     int data = 0;
//     while(true)
//     {   
//         //生产
//         data++;
//         //发送
//         bq->Enqueue(data);
//         std::cout<<"生产了一个数据 data = "<<data<<std::endl;
//         //sleep(1);
//     }
//     return nullptr;
// }


// void* cRoutine(void* args)
// {
//     BlockQueue<int>* bq = static_cast<BlockQueue<int>*>(args);

//     while(true)
//     {
//         sleep(2);
//         //取数据
//         int data = bq->Pop();
//         //执行
//         std::cout<<"消费了一个数据 data = "<<data<<std::endl;
//     }
//     return nullptr;
// }


// //测试基于阻塞队列的单生产单消费模型
// int main()
// {
//     pthread_t productor,consumer;
//     BlockQueue<int> bq;    

//     pthread_create(&productor,nullptr,pRoutine,&bq);
//     pthread_create(&consumer,nullptr,cRoutine,&bq);

//     sleep(1000);

//     pthread_join(productor,nullptr);
//     pthread_join(consumer,nullptr);

//     return 0;
// }


// //测试传任务类
// void* pRoutine(void* args)
// {
//     BlockQueue<Task>* bq = static_cast<BlockQueue<Task>*>(args);
//     int a = 1,b = 1;
//     while(true)
//     {   
//         //生产
//         Task task(a,b);
//         //发送
//         bq->Enqueue(task);
//         std::cout<<"生产了一个任务"<<a<<" + "<<b<<" = ?"<<std::endl;
//         a++,b++;
//         //sleep(1);
//     }
//     return nullptr;
// }


// void* cRoutine(void* args)
// {
//     BlockQueue<Task>* bq = static_cast<BlockQueue<Task>*>(args);

//     while(true)
//     {
//         sleep(2);
//         //取任务
//         Task task = bq->Pop();
//         task.Execute();
//         //执行
//         std::cout<<"消费了一个任务"<<task.GetA()<<" + "<<task.GetB()<<" = "<<task.GetRet()<<std::endl;

//     }
//     return nullptr;
// }




//测试传任务函数
void* pRoutine(void* args)
{
    BlockQueue<task_t>* bq = static_cast<BlockQueue<task_t>*>(args);
    while(true)
    {   
        //1.获得任务

        //...从其他模块获取任务（如网络）

        //2.生产任务
        bq->Enqueue(Download);
        sleep(1);
    }
    return nullptr;
}

void* cRoutine(void* args)
{
    BlockQueue<task_t>* bq = static_cast<BlockQueue<task_t>*>(args);

    while(true)
    {
        //sleep(1);
        //消费任务
        task_t task = bq->Pop();

        //处理任务-这个任务已经拿到当前线程的上下文，不属于队列了
        task();

    }
    return nullptr;
}



//测试基于阻塞队列的单生产单消费模型
int main()
{
    pthread_t productor,consumer;
    //BlockQueue<Task> bq;    
    BlockQueue<task_t> bq;    

    pthread_create(&productor,nullptr,pRoutine,&bq);
    pthread_create(&consumer,nullptr,cRoutine,&bq);

    //sleep(1000);

    pthread_join(productor,nullptr);
    pthread_join(consumer,nullptr);

    return 0;
}



// //测试基于阻塞队列的 多生产多消费 模型
// int main()
// {
//     pthread_t p[3],c[2];
//     //BlockQueue<Task> bq;    
//     BlockQueue<task_t> bq;    

//     pthread_create(&p[0],nullptr,pRoutine,&bq);
//     pthread_create(&p[1],nullptr,pRoutine,&bq);
//     pthread_create(&p[2],nullptr,pRoutine,&bq);
//     pthread_create(&c[1],nullptr,cRoutine,&bq);
//     pthread_create(&c[0],nullptr,cRoutine,&bq);


//     pthread_join(p[0],nullptr);
//     pthread_join(p[1],nullptr);
//     pthread_join(p[2],nullptr);
//     pthread_join(c[1],nullptr);
//     pthread_join(c[0],nullptr);

//     return 0;
// }